using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;

using ILRuntime.CLR.TypeSystem;
using ILRuntime.CLR.Method;
using ILRuntime.Runtime.Enviorment;
using ILRuntime.Runtime.Intepreter;
using ILRuntime.Runtime.Stack;
using ILRuntime.Reflection;
using ILRuntime.CLR.Utils;
using System.Linq;

namespace ILRuntime.Runtime.Generated
{
    unsafe class huqiang_Core_UIData_HGraphicsData_Binding
    {
        public static void Register(ILRuntime.Runtime.Enviorment.AppDomain app)
        {
            BindingFlags flag = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
            FieldInfo field;
            Type[] args;
            Type type = typeof(huqiang.Core.UIData.HGraphicsData);

            field = type.GetField("element", flag);
            app.RegisterCLRFieldGetter(field, get_element_0);
            app.RegisterCLRFieldSetter(field, set_element_0);
            app.RegisterCLRFieldBinding(field, CopyToStack_element_0, AssignFromStack_element_0);
            field = type.GetField("shader", flag);
            app.RegisterCLRFieldGetter(field, get_shader_1);
            app.RegisterCLRFieldSetter(field, set_shader_1);
            app.RegisterCLRFieldBinding(field, CopyToStack_shader_1, AssignFromStack_shader_1);
            field = type.GetField("asset", flag);
            app.RegisterCLRFieldGetter(field, get_asset_2);
            app.RegisterCLRFieldSetter(field, set_asset_2);
            app.RegisterCLRFieldBinding(field, CopyToStack_asset_2, AssignFromStack_asset_2);
            field = type.GetField("MainTexture", flag);
            app.RegisterCLRFieldGetter(field, get_MainTexture_3);
            app.RegisterCLRFieldSetter(field, set_MainTexture_3);
            app.RegisterCLRFieldBinding(field, CopyToStack_MainTexture_3, AssignFromStack_MainTexture_3);
            field = type.GetField("STexture", flag);
            app.RegisterCLRFieldGetter(field, get_STexture_4);
            app.RegisterCLRFieldSetter(field, set_STexture_4);
            app.RegisterCLRFieldBinding(field, CopyToStack_STexture_4, AssignFromStack_STexture_4);
            field = type.GetField("TTexture", flag);
            app.RegisterCLRFieldGetter(field, get_TTexture_5);
            app.RegisterCLRFieldSetter(field, set_TTexture_5);
            app.RegisterCLRFieldBinding(field, CopyToStack_TTexture_5, AssignFromStack_TTexture_5);
            field = type.GetField("FTexture", flag);
            app.RegisterCLRFieldGetter(field, get_FTexture_6);
            app.RegisterCLRFieldSetter(field, set_FTexture_6);
            app.RegisterCLRFieldBinding(field, CopyToStack_FTexture_6, AssignFromStack_FTexture_6);
            field = type.GetField("color", flag);
            app.RegisterCLRFieldGetter(field, get_color_7);
            app.RegisterCLRFieldSetter(field, set_color_7);
            app.RegisterCLRFieldBinding(field, CopyToStack_color_7, AssignFromStack_color_7);
            field = type.GetField("uvRect", flag);
            app.RegisterCLRFieldGetter(field, get_uvRect_8);
            app.RegisterCLRFieldSetter(field, set_uvRect_8);
            app.RegisterCLRFieldBinding(field, CopyToStack_uvRect_8, AssignFromStack_uvRect_8);
            field = type.GetField("Shadow", flag);
            app.RegisterCLRFieldGetter(field, get_Shadow_9);
            app.RegisterCLRFieldSetter(field, set_Shadow_9);
            app.RegisterCLRFieldBinding(field, CopyToStack_Shadow_9, AssignFromStack_Shadow_9);
            field = type.GetField("shadowOffsset", flag);
            app.RegisterCLRFieldGetter(field, get_shadowOffsset_10);
            app.RegisterCLRFieldSetter(field, set_shadowOffsset_10);
            app.RegisterCLRFieldBinding(field, CopyToStack_shadowOffsset_10, AssignFromStack_shadowOffsset_10);
            field = type.GetField("shadowColor", flag);
            app.RegisterCLRFieldGetter(field, get_shadowColor_11);
            app.RegisterCLRFieldSetter(field, set_shadowColor_11);
            app.RegisterCLRFieldBinding(field, CopyToStack_shadowColor_11, AssignFromStack_shadowColor_11);
            field = type.GetField("Size", flag);
            app.RegisterCLRFieldGetter(field, get_Size_12);
            app.RegisterCLRFieldSetter(field, set_Size_12);
            app.RegisterCLRFieldBinding(field, CopyToStack_Size_12, AssignFromStack_Size_12);
            field = type.GetField("ElementSize", flag);
            app.RegisterCLRFieldGetter(field, get_ElementSize_13);
            app.RegisterCLRFieldSetter(field, set_ElementSize_13);
            app.RegisterCLRFieldBinding(field, CopyToStack_ElementSize_13, AssignFromStack_ElementSize_13);

            app.RegisterCLRMemberwiseClone(type, PerformMemberwiseClone);

            app.RegisterCLRCreateDefaultInstance(type, () => new huqiang.Core.UIData.HGraphicsData());
            app.RegisterCLRCreateArrayInstance(type, s => new huqiang.Core.UIData.HGraphicsData[s]);


        }

        static void WriteBackInstance(ILRuntime.Runtime.Enviorment.AppDomain __domain, StackObject* ptr_of_this_method, IList<object> __mStack, ref huqiang.Core.UIData.HGraphicsData instance_of_this_method)
        {
            ptr_of_this_method = ILIntepreter.GetObjectAndResolveReference(ptr_of_this_method);
            switch(ptr_of_this_method->ObjectType)
            {
                case ObjectTypes.Object:
                    {
                        __mStack[ptr_of_this_method->Value] = instance_of_this_method;
                    }
                    break;
                case ObjectTypes.FieldReference:
                    {
                        var ___obj = __mStack[ptr_of_this_method->Value];
                        if(___obj is ILTypeInstance)
                        {
                            ((ILTypeInstance)___obj)[ptr_of_this_method->ValueLow] = instance_of_this_method;
                        }
                        else
                        {
                            var t = __domain.GetType(___obj.GetType()) as CLRType;
                            t.SetFieldValue(ptr_of_this_method->ValueLow, ref ___obj, instance_of_this_method);
                        }
                    }
                    break;
                case ObjectTypes.StaticFieldReference:
                    {
                        var t = __domain.GetType(ptr_of_this_method->Value);
                        if(t is ILType)
                        {
                            ((ILType)t).StaticInstance[ptr_of_this_method->ValueLow] = instance_of_this_method;
                        }
                        else
                        {
                            ((CLRType)t).SetStaticFieldValue(ptr_of_this_method->ValueLow, instance_of_this_method);
                        }
                    }
                    break;
                 case ObjectTypes.ArrayReference:
                    {
                        var instance_of_arrayReference = __mStack[ptr_of_this_method->Value] as huqiang.Core.UIData.HGraphicsData[];
                        instance_of_arrayReference[ptr_of_this_method->ValueLow] = instance_of_this_method;
                    }
                    break;
            }
        }


        static object get_element_0(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).element;
        }

        static StackObject* CopyToStack_element_0(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).element;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_element_0(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.element = (huqiang.Core.UIData.UIElementData)v;
            o = ins;
        }

        static StackObject* AssignFromStack_element_0(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Core.UIData.UIElementData @element = (huqiang.Core.UIData.UIElementData)typeof(huqiang.Core.UIData.UIElementData).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.element = @element;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_shader_1(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).shader;
        }

        static StackObject* CopyToStack_shader_1(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).shader;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_shader_1(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.shader = (huqiang.Data.StringPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_shader_1(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.StringPoint @shader = (huqiang.Data.StringPoint)typeof(huqiang.Data.StringPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.shader = @shader;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_asset_2(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).asset;
        }

        static StackObject* CopyToStack_asset_2(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).asset;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_asset_2(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.asset = (huqiang.Data.StringPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_asset_2(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.StringPoint @asset = (huqiang.Data.StringPoint)typeof(huqiang.Data.StringPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.asset = @asset;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_MainTexture_3(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).MainTexture;
        }

        static StackObject* CopyToStack_MainTexture_3(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).MainTexture;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_MainTexture_3(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.MainTexture = (huqiang.Data.StringPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_MainTexture_3(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.StringPoint @MainTexture = (huqiang.Data.StringPoint)typeof(huqiang.Data.StringPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.MainTexture = @MainTexture;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_STexture_4(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).STexture;
        }

        static StackObject* CopyToStack_STexture_4(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).STexture;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_STexture_4(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.STexture = (huqiang.Data.StringPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_STexture_4(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.StringPoint @STexture = (huqiang.Data.StringPoint)typeof(huqiang.Data.StringPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.STexture = @STexture;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_TTexture_5(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).TTexture;
        }

        static StackObject* CopyToStack_TTexture_5(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).TTexture;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_TTexture_5(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.TTexture = (huqiang.Data.StringPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_TTexture_5(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.StringPoint @TTexture = (huqiang.Data.StringPoint)typeof(huqiang.Data.StringPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.TTexture = @TTexture;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_FTexture_6(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).FTexture;
        }

        static StackObject* CopyToStack_FTexture_6(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).FTexture;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_FTexture_6(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.FTexture = (huqiang.Data.StringPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_FTexture_6(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.StringPoint @FTexture = (huqiang.Data.StringPoint)typeof(huqiang.Data.StringPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.FTexture = @FTexture;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_color_7(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).color;
        }

        static StackObject* CopyToStack_color_7(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).color;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_color_7(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.color = (UnityEngine.Color32)v;
            o = ins;
        }

        static StackObject* AssignFromStack_color_7(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Color32 @color = (UnityEngine.Color32)typeof(UnityEngine.Color32).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.color = @color;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_uvRect_8(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).uvRect;
        }

        static StackObject* CopyToStack_uvRect_8(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).uvRect;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_uvRect_8(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.uvRect = (UnityEngine.Vector4)v;
            o = ins;
        }

        static StackObject* AssignFromStack_uvRect_8(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Vector4 @uvRect = (UnityEngine.Vector4)typeof(UnityEngine.Vector4).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.uvRect = @uvRect;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_Shadow_9(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).Shadow;
        }

        static StackObject* CopyToStack_Shadow_9(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).Shadow;
            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value = result_of_this_method ? 1 : 0;
            return __ret + 1;
        }

        static void set_Shadow_9(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.Shadow = (System.Boolean)v;
            o = ins;
        }

        static StackObject* AssignFromStack_Shadow_9(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            System.Boolean @Shadow = ptr_of_this_method->Value == 1;
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.Shadow = @Shadow;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_shadowOffsset_10(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).shadowOffsset;
        }

        static StackObject* CopyToStack_shadowOffsset_10(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).shadowOffsset;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_shadowOffsset_10(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.shadowOffsset = (UnityEngine.Vector2)v;
            o = ins;
        }

        static StackObject* AssignFromStack_shadowOffsset_10(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Vector2 @shadowOffsset = (UnityEngine.Vector2)typeof(UnityEngine.Vector2).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.shadowOffsset = @shadowOffsset;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_shadowColor_11(ref object o)
        {
            return ((huqiang.Core.UIData.HGraphicsData)o).shadowColor;
        }

        static StackObject* CopyToStack_shadowColor_11(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.HGraphicsData)o).shadowColor;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_shadowColor_11(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.shadowColor = (UnityEngine.Color32)v;
            o = ins;
        }

        static StackObject* AssignFromStack_shadowColor_11(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Color32 @shadowColor = (UnityEngine.Color32)typeof(UnityEngine.Color32).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.HGraphicsData ins =(huqiang.Core.UIData.HGraphicsData)o;
            ins.shadowColor = @shadowColor;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_Size_12(ref object o)
        {
            return huqiang.Core.UIData.HGraphicsData.Size;
        }

        static StackObject* CopyToStack_Size_12(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = huqiang.Core.UIData.HGraphicsData.Size;
            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value = result_of_this_method;
            return __ret + 1;
        }

        static void set_Size_12(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData.Size = (System.Int32)v;
        }

        static StackObject* AssignFromStack_Size_12(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            System.Int32 @Size = ptr_of_this_method->Value;
            huqiang.Core.UIData.HGraphicsData.Size = @Size;
            return ptr_of_this_method;
        }

        static object get_ElementSize_13(ref object o)
        {
            return huqiang.Core.UIData.HGraphicsData.ElementSize;
        }

        static StackObject* CopyToStack_ElementSize_13(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = huqiang.Core.UIData.HGraphicsData.ElementSize;
            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value = result_of_this_method;
            return __ret + 1;
        }

        static void set_ElementSize_13(ref object o, object v)
        {
            huqiang.Core.UIData.HGraphicsData.ElementSize = (System.Int32)v;
        }

        static StackObject* AssignFromStack_ElementSize_13(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            System.Int32 @ElementSize = ptr_of_this_method->Value;
            huqiang.Core.UIData.HGraphicsData.ElementSize = @ElementSize;
            return ptr_of_this_method;
        }


        static object PerformMemberwiseClone(ref object o)
        {
            var ins = new huqiang.Core.UIData.HGraphicsData();
            ins = (huqiang.Core.UIData.HGraphicsData)o;
            return ins;
        }


    }
}
